let i = void 2 // i === undefined

void (function aRecursion(i) {
  if (i > 0) {
    console.log(i--)
    aRecursion(i)
  }
})(3)

console.log(typeof aRecursion) // undefined

// returning something else than undefined would crash the app
function middleware(nextCallback) {
  if (conditionApplies()) {
    return void nextCallback()
  }
}
// or
button.onclick = () => void doSomething()

function doSomething(callback: () => void) {
  // at this position, callback always returns undefined
  let c = callback()
  //c is also of type undefiend
}

// this function returns a number
function aNumberCallback(): number {
  return 2;
}

// works 👍 type safety is ensured in doSometing
doSomething(aNumberCallback)

// if you change the code above like
- function doSomething(callback: () => void) {
+ function doSomething(callback: () => undefined) { /* ... */ }

function aNumberCallback(): number { return 2; }

// 💥 types don't match
doSomething(aNumberCallback)

let msg: string = "hello there!"
// equal to
let msg = "hello there!"

tsc --target es2015 input.ts

// 抛出异常的函数永远不会有返回值
function error(message: string): never {
    throw new Error(message);
}
// 空数组，而且永远是空的
const empty: never[] = []

let x: [string, number];
x = ['hello', 10, false] // Error
x = ['hello'] // Error

let x: [string, number];
x = ['hello', 10]; // OK
x = [10, 'hello']; // Error

interface Tuple extends Array<string | number> {
  0: string;
  1: number;
  length: 2;
}

// 这是下一节会提到的枚举类型
enum Direction {
    Center = 1
}
let value: object
value = Direction
value = [1]
value = [1, 'hello']
value = {}

enum Direction {
  Up = 10,
  Down,
  Left,
  Right,
}

var Direction
;(function (Direction) {
  Direction[(Direction["Up"] = 10)] = "Up"
  Direction[(Direction["Down"] = 11)] = "Down"
  Direction[(Direction["Left"] = 12)] = "Left"
  Direction[(Direction["Right"] = 13)] = "Right"
})(Direction || (Direction = {}))

enum Enum {
  A,
}

let a = Enum.A;
let nameOfA = Enum[a]; // "A"

let x: "hello" = "hello"
// OK
x = "hello"
// Type '"howdy"' is not assignable to type '"hello"'.
x = "howdy"

function printText(s: string, alignment: "left" | "right" | "center") {
  // ...
}
printText("Hello, world", "left")
printText("G'day, mate", "centre")
// Argument of type '"centre"' is not assignable to parameter of type '"left" | "right" | "center"'.

function compare(a: string, b: string): -1 | 0 | 1 {
  return a === b ? 0 : a > b ? 1 : -1
}

interface Options {
  width: number
}
function configure(x: Options | "auto") {
  // ...
}
configure({ width: 100 })
configure("auto")
configure("automatic")
// Argument of type '"automatic"' is not assignable to parameter of type 'Options | "auto"'.

const obj = { counter: 0 }
if (someCondition) {
  obj.counter = 1
}

const req = { url: "https://example.com", method: "GET" }
handleRequest(req.url, req.method)
// Argument of type 'string' is not assignable to parameter of type '"GET" | "POST"'.

// Change 1:
const req = { url: "https://example.com", method: "GET" as "GET" }
// Change 2
handleRequest(req.url, req.method as "GET")

const req = { url: "https://example.com", method: "GET" } as const
handleRequest(req.url, req.method)

// Extending an interface
interface Animal {
  name: string
}

interface Bear extends Animal {
  honey: boolean
}

const bear = getBear()
bear.name
bear.honey

// Extending a type via intersections
type Animal = {
  name: string
}

type Bear = Animal & {
  honey: Boolean
}

const bear = getBear()
bear.name
bear.honey

// Adding new fields to an existing interface
interface Window {
  title: string
}

interface Window {
  ts: TypeScriptAPI
}

const src = 'const a = "Hello World"'
window.ts.transpileModule(src, {})

// A type cannot be changed after being created
type Window = {
  title: string
}

type Window = {
  ts: TypeScriptAPI
}

// Error: Duplicate identifier 'Window'.

// Compiler error messages will always use
// the name of an interface:

interface Mammal {
  name: string
}

function echoMammal(m: Mammal) {
  console.log(m.name)
}

// e.g. The error below will always use the name Mammal
// to refer to the type which is expected:
echoMammal({ name: 12343 })

// The type of `m` here is the exact same as mammal,
// but as it's not been directly named, TypeScript
// won't mention it in the error messaging

function echoAnimal(m: { name: string }) {
  console.log(m.name)
}

echoAnimal({ name: 12345 })

undefined as number

interface A {
  a1: number
  a2: Record<string, unknown>
}
declare let b: Record<string, unknown>
b as A // error
;(b as unknown) as A // pass

type DescribableFunction = {
  description: string
  (someArg: number): boolean
}
function doSomething(fn: DescribableFunction) {
  console.log(fn.description + " returned " + fn(6))
}

type SomeConstructor = {
  new (s: string): SomeObject
}
function fn(ctor: SomeConstructor) {
  return new ctor("hello")
}

interface CallOrConstruct {
  new (s: string): Date
  (n?: number): number
}

function firstElement<Type>(arr: Type[]): Type {
  return arr[0]
}

// s is of type 'string'
const s = firstElement(["a", "b", "c"])
// n is of type 'number'
const n = firstElement([1, 2, 3])

function longest<Type extends { length: number }>(a: Type, b: Type) {
  if (a.length >= b.length) {
    return a
  } else {
    return b
  }
}

// longerArray is of type 'number[]'
const longerArray = longest([1, 2], [1, 2, 3])
// longerString is of type 'string'
const longerString = longest("alice", "bob")
// Error! Numbers don't have a 'length' property
const notOK = longest(10, 100)

function minimumLength<Type extends { length: number }>(
  obj: Type,
  minimum: number
): Type {
  if (obj.length >= minimum) {
    return obj
  } else {
    return { length: minimum }
    // Type '{ length: number; }' is not assignable to type 'Type'. '{ length: number; }' is assignable to the constraint of type 'Type', but 'Type' could be instantiated with a different subtype of constraint '{ length: number; }'.
  }
}

// 'arr' gets value { length: 6 }
const arr = minimumLength([1, 2, 3], 6)
// and crashes here because arrays have
// a 'slice' method, but not the returned object!
console.log(arr.slice(0))

function combine<Type>(arr1: Type[], arr2: Type[]): Type[] {
  return arr1.concat(arr2)
}

// Type 'string' is not assignable to type 'number'.
const arr = combine([1, 2, 3], ["hello"])

// Correct
const arr = combine<string | number>([1, 2, 3], ["hello"])

interface ReturnItemFn<T> {
    (para: T): T
}

const returnItem: ReturnItemFn<number> = para => para

class Stack {
    private arr: number[] = []
    public push(item: number) {
        this.arr.push(item)
    }
    public pop() {
        this.arr.pop()
    }
}

class Stack<T> {
    private arr: T[] = []
    public push(item: T) {
        this.arr.push(item)
    }
    public pop() {
        this.arr.pop()
    }
}

function firstElement1<Type>(arr: Type[]) {
  return arr[0]
}

function firstElement2<Type extends any[]>(arr: Type) {
  return arr[0]
}

// a: number (good)
const a = firstElement1([1, 2, 3])
// b: any (bad)
const b = firstElement2([1, 2, 3])

function filter1<Type>(arr: Type[], func: (arg: Type) => boolean): Type[] {
  return arr.filter(func)
}

function filter2<Type, Func extends (arg: Type) => boolean>(
  arr: Type[],
  func: Func
): Type[] {
  return arr.filter(func)
}

function greet<Str extends string>(s: Str) {
  console.log("Hello, " + s)
}

greet("world")

function greet(s: string) {
  console.log("Hello, " + s)
}

function makeDate(timestamp: number): Date
function makeDate(m: number, d: number, y: number): Date
function makeDate(mOrTimestamp: number, d?: number, y?: number): Date {
  if (d !== undefined && y !== undefined) {
    return new Date(y, mOrTimestamp, d)
  } else {
    return new Date(mOrTimestamp)
  }
}
const d1 = makeDate(12345678)
const d2 = makeDate(5, 5, 5)
const d3 = makeDate(1, 3)

function fn(x: string): void;
function fn() {
  // ...
}
// Expected to be able to call with zero arguments
fn();
Expected 1 arguments, but got 0.

function fn(x: boolean): void
// Argument type isn't right
function fn(x: string): void
// This overload signature is not compatible with its implementation signature.
function fn(x: boolean) {}

function len(s: string): number
function len(arr: any[]): number
function len(x: any) {
  return x.length
}

len("") // OK
len([0]) // OK
len(Math.random() > 0.5 ? "hello" : [0])
/** 
  No overload matches this call.
  Overload 1 of 2, '(s: string): number', gave the following error.
    Argument of type 'number[] | "hello"' is not assignable to parameter of type 'string'.
      Type 'number[]' is not assignable to type 'string'.
  Overload 2 of 2, '(arr: any[]): number', gave the following error.
    Argument of type 'number[] | "hello"' is not assignable to parameter of type 'any[]'.
      Type 'string' is not assignable to type 'any[]'.
*/

// this is better
function len(x: any[] | string) {
  return x.length
}

type Partial<T> = { [P in keyof T]?: T[P] };

interface Company {
    id: number
    name: string
}
interface Person {
    id: number
    name: string
    adress: string
    company: Company
}
type R1 = Partial<Person>

type DeepPartial<T> = {
    [U in keyof T]?: T[U] extends object
    ? DeepPartial<T[U]>
    : T[U]
};
type R2 = DeepPartial<Person>

type Required<T> = { [P in keyof T]-?: T[P] };

type Exclude<T, U> = T extends U ? never : T;
type T = Exclude<1 | 2, 1 | 3> // -> 2

type Omit<T, K> = Pick<T, Exclude<keyof T, K>>
type Foo = Omit<{name: string, age: number}, 'name'> // -> { age: number }

type O1 = {
  name: string
  id: number
}
type O2 = {
  id: number
  from: string
}
type R2 = Merge<O1, O2>

type Compute<A extends any> =
    A extends Function
    ? A
    : { [K in keyof A]: A[K] }
type R1 = Compute<{x: 'x'} & {y: 'y'}>

type Merge<O1 extends object, O2 extends object> =
    Compute<O1 & Omit<O2, keyof O1>>

type Props = { name: string; age: number; visible: boolean };
type DefaultProps = { age: number };
// Expect: { age: number; }
type DuplicatedProps = Intersection<Props, DefaultProps>;

type Intersection<T extends object, U extends object> = Pick<
  T,
  Extract<keyof T, keyof U> & Extract<keyof U, keyof T>
>;

type Props = { name: string; age: number; visible: boolean };
type NewProps = { age: string; other: string };
// Expect: { name: string; age: string; visible: boolean; }
type ReplacedProps = Overwrite<Props, NewProps>

type Overwrite<
  T extends object,
  U extends object,
  I = Diff<T, U> & Intersection<U, T>
> = Pick<I, keyof I>;

type Mutable<T> = {
  -readonly [P in keyof T]: T[P]
}

export class SingletonService<T> {
    readonly type: T
    readonly newable: new() => T
    private instance: T

    constructor(newable: new() => T) {
      this.newable = newable;
    }

    getInstance(): T {
      if(!this.instance) {
        this.instance = new this.newable();
      }
      return this.instance; 
    }
}

class myNumberClass {
    num: number;

    constructor() {
        this.num = 0;
    }

    add() {
        this.num++;
    }
}

let myNumberSS = new SingletonService<myNumberClass>(myNumberClass)

const ss: myNumberClass = myNumberSS.getInstance();

console.log(ss.num)
ss.add();
console.log(ss.num)
ss.add();

const ss2: myNumberClass = myNumberSS.getInstance();
console.log(ss2.num)